import java.util.Arrays;

/**
 * ClassName: PersonTest
 * Description:
 *
 * @Author liu
 * @Create 2024/11/28 22:56
 * @Version 1.0
 */
public class test2 {
}
//28.找出字符串中第一个匹配项的下标
//给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。

//示例 1：
//
//输入：haystack = "sadbutsad", needle = "sad"
//输出：0
//解释："sad" 在下标 0 和 6 处匹配。
//第一个匹配项的下标是 0 ，所以返回 0 。
//示例 2：
//
//输入：haystack = "leetcode", needle = "leeto"
//输出：-1
//解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
class Solutiona {
    public int strStr(String haystack, String needle) {
        return haystack.indexOf(needle);
    }
}



//242.有效的字母异位词
//给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的
//字母异位词
//示例 1:
//
//输入: s = "anagram", t = "nagaram"
//输出: true
//示例 2:
//
//输入: s = "rat", t = "car"
//输出: false

class Solutionb {
    public boolean isAnagram(String s, String t) {
//优化前
        //1.ASCLL
        // int[] contS = new int[26];
        // for(char ch:s.toCharArray()){
        //     contS[ch -'a']++;
        // }
        // int[] contT = new int[26];
        // for(char ch:t.toCharArray()){
        //     contT[ch -'a']++;
        // }
        // return Arrays.equals(contS,contT);

//优化后
        int[] cont = new int[26];
        for(char ch: s.toCharArray()){
            cont[ch - 'a']++;
        }
        for(char ch:t.toCharArray()){
            cont[ch -'a']--;
        }
        for(int c : cont){
            if(c !=0){
                return false;
            }
        }
        return true;



//排序
        // if(s.length() != t.length()){
        //     return false;
        // }

        // char[] str1 = s.toCharArray();
        // char[] str2 = t.toCharArray();

        // Arrays.sort(str1);
        // Arrays.sort(str2);

        // return Arrays.equals(str1,str2);
    }
}



//459.重复的子字符串
//给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
//
//
//
//示例 1:
//
//输入: s = "abab"
//输出: true
//解释: 可由子串 "ab" 重复两次构成。
//示例 2:
//
//输入: s = "aba"
//输出: false
//示例 3:
//
//输入: s = "abcabcabcabc"
//输出: true
//解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)
class Solutionc {
    public boolean repeatedSubstringPattern(String s) {
        return (s+s).indexOf(s,1) !=s.length();

    }
}


//283.移动零
//给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
//
//请注意 ，必须在不复制数组的情况下原地对数组进行操作。
//
//
//
//示例 1:
//
//输入: nums = [0,1,0,3,12]
//输出: [1,3,12,0,0]
//示例 2:
//
//输入: nums = [0]
//输出: [0]
class Solutiond {
    public void moveZeroes(int[] nums) {
        int n=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i] != 0){
                int temp =nums[i];
                nums[i] =nums[n];
                nums[n++] =temp;
            }
        }
    }
}


//66.加一
//给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
//
//最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
//
//你可以假设除了整数 0 之外，这个整数不会以零开头。
//
//
//
//示例 1：
//
//输入：digits = [1,2,3]
//输出：[1,2,4]
//解释：输入数组表示数字 123。
//示例 2：
//
//输入：digits = [4,3,2,1]
//输出：[4,3,2,2]
//解释：输入数组表示数字 4321。

class Solutione {
    public int[] plusOne(int[] digits) {
        int n = digits.length;
        for (int i = n - 1; i >= 0; i--) {
            if (digits[i] == 9) {
                digits[i] = 0;
            } else {
                digits[i] += 1;
                return digits;
            }
        }
        //99 999
        digits = new int[n + 1];
        digits[0] = 1;
        return digits;
    }
}

//1822.数组元素积的符号
//已知函数 signFunc(x) 将会根据 x 的正负返回特定值：
//
//如果 x 是正数，返回 1 。
//如果 x 是负数，返回 -1 。
//如果 x 是等于 0 ，返回 0 。
//给你一个整数数组 nums 。令 product 为数组 nums 中所有元素值的乘积。
//
//返回 signFunc(product) 。
//
//
//
//示例 1：
//
//输入：nums = [-1,-2,-3,-4,3,2,1]
//输出：1
//解释：数组中所有值的乘积是 144 ，且 signFunc(144) = 1
//示例 2：
//
//输入：nums = [1,5,0,2,-3]
//输出：0
//解释：数组中所有值的乘积是 0 ，且 signFunc(0) = 0
//示例 3：
//
//输入：nums = [-1,1,-1,1,-1]
//输出：-1
//解释：数组中所有值的乘积是 -1 ，且 signFunc(-1) = -1
class Solutionf {
    public int arraySign(int[] nums) {
        int ans = 1;
        for(int x : nums){
            if(x == 0) return 0;
            if(x < 0){
                //ans*= -1;
                ans++;
            }

        }
        //return ans;
        return ans % 2 == 0? -1:1;
    }
}

//1502.判断能否形成等差数列
//给你一个数字数组 arr 。
//
//如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 等差数列 。
//
//如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。
//
//
//
//示例 1：
//
//输入：arr = [3,5,1]
//输出：true
//解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。
//示例 2：
//
//输入：arr = [1,2,4]
//输出：false
//解释：无法通过重新排序得到等差数列。
class Solutiong {
    public boolean canMakeArithmeticProgression(int[] arr) {
        Arrays.sort(arr);
        //arr从第二个开始，2b=a+c;
        for(int i=1;i<arr.length-1;i++){
            if(arr[i] *2 != arr[i-1] + arr[i+1]){
                return false;
            }
        }
        return true;
    }
}

// 896.单调数列
//如果数组是单调递增或单调递减的，那么它是 单调 的。
//
//如果对于所有 i <= j，nums[i] <= nums[j]，那么数组 nums 是单调递增的。 如果对于所有 i <= j，nums[i]> = nums[j]，那么数组 nums 是单调递减的。
//
//当给定的数组 nums 是单调数组时返回 true，否则返回 false。
//
//
//
//示例 1：
//
//输入：nums = [1,2,2,3]
//输出：true
//示例 2：
//
//输入：nums = [6,5,4,4]
//输出：true
class Solutionh {
    public boolean isMonotonic(int[] nums) {
        boolean  c =true,d=true;
        //判断又增又减--->false
        for(int i= 0;i<nums.length-1;i++){//-1
            //判断增
            if(nums[i] < nums[i+1]){
                c = false;
            }
            //判断减
            if(nums[i] >nums[i+1]){
                d = false;
            }
        }
        return c || d;
    }
}